{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "5fbc2d16-59f9-4be3-b93e-1a5440c7efd0",
   "metadata": {},
   "source": [
    "# Tutorial 5 - Adaptive PIKANs"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1afe6a1e-3ab4-4f3f-ad47-f6cd66419504",
   "metadata": {},
   "source": [
    "In Tutorial 3 we got a taste of solving PDEs using KANs and in Tutorial 4 we started exploring adaptive training techniques. Blending these two together, in this tutorial we will see how to adaptively train PIKANs, based on the findings of [this](https://ieeexplore.ieee.org/document/10763509) paper."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "0a2ef2a6-f681-427f-8252-ade2111ce0e6",
   "metadata": {},
   "outputs": [],
   "source": [
    "from jaxkan.KAN import KAN\n",
    "\n",
    "import jax\n",
    "import jax.numpy as jnp\n",
    "\n",
    "from jaxkan.utils.PIKAN import sobol_sample, gradf, get_adaptive_loss\n",
    "from jaxkan.utils.general import adam_transition\n",
    "\n",
    "from flax import nnx\n",
    "import optax\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "60e70a5d-0340-4bdc-af4e-150d0098a87e",
   "metadata": {},
   "source": [
    "## Data Generation"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "166ad90d-430e-45ca-86a8-e6e4dbc1c943",
   "metadata": {},
   "source": [
    "Burgers' Equation was relatively easy to solve even without adaptive techniques, so in this case we will be solving the Allen-Cahn Equation,\n",
    "\n",
    "$$ \\frac{\\partial u}{\\partial t} - D\\frac{\\partial^2 u}{\\partial x^2} + 5 \\left(u^3 - u\\right) = 0,$$\n",
    "\n",
    "for $D = 10^{-3}$ in the $\\Omega = [0,1]\\times [-1, 1]$ domain, subject to the boundary conditions\n",
    "\n",
    "$$ u\\left(t=0, x\\right) = x^2 \\cos\\left(\\pi x\\right), $$\n",
    "\n",
    "$$ u\\left(t, x=-1\\right) = u\\left(t, x=1\\right) = -1. $$\n",
    "\n",
    "In the following, we must first define the corresponding collocation points, again using Sobol sampling."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "b986e75a-6d4a-402f-bea7-36d13f4a7866",
   "metadata": {},
   "outputs": [],
   "source": [
    "seed = 42\n",
    "\n",
    "# Generate Collocation points for PDE\n",
    "N = 2**12\n",
    "collocs = jnp.array(sobol_sample(np.array([0,-1]), np.array([1,1]), N, seed)) # (4096, 2)\n",
    "\n",
    "# Generate Collocation points for BCs\n",
    "N = 2**6\n",
    "\n",
    "BC1_colloc = jnp.array(sobol_sample(np.array([0,-1]), np.array([0,1]), N, seed)) # (64, 2)\n",
    "BC1_data = ((BC1_colloc[:,1]**2)*jnp.cos(jnp.pi*BC1_colloc[:,1])).reshape(-1,1)\n",
    "\n",
    "BC2_colloc = jnp.array(sobol_sample(np.array([0,-1]), np.array([1,-1]), N, seed)) # (64, 2)\n",
    "BC2_data = -jnp.ones(BC2_colloc.shape[0]).reshape(-1,1) # (64, 1)\n",
    "\n",
    "BC3_colloc = jnp.array(sobol_sample(np.array([0,1]), np.array([1,1]), N, seed)) # (64, 2)\n",
    "BC3_data = -jnp.ones(BC3_colloc.shape[0]).reshape(-1,1) # (64, 1)\n",
    "\n",
    "# Create lists for BCs\n",
    "bc_collocs = [BC1_colloc, BC2_colloc, BC3_colloc]\n",
    "bc_data = [BC1_data, BC2_data, BC3_data]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4e9d9bba-71e2-4d5b-95b1-36167fb70c1a",
   "metadata": {},
   "source": [
    "## KAN Model"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2fd54c6c-3d28-4864-af38-3b22875d0f0a",
   "metadata": {},
   "source": [
    "We covered KAN Model selection in the first tutorial, so feel free to refer to it for more info. For this example, we will be using the `spline` KAN Layer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "b350b56f-5daa-411f-9090-b544760c34ef",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initialize a KAN model\n",
    "n_in = collocs.shape[1]\n",
    "n_out = 1\n",
    "n_hidden = 8\n",
    "\n",
    "layer_dims = [n_in, n_hidden, n_hidden, n_out]\n",
    "req_params = {'k': 4, 'G': 3, 'grid_e': 0.02}\n",
    "\n",
    "model = KAN(layer_dims = layer_dims,\n",
    "            layer_type = 'spline',\n",
    "            required_parameters = req_params,\n",
    "            seed = seed\n",
    "           )\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f681d135-c885-4e59-87d7-1ea16a157c50",
   "metadata": {},
   "source": [
    "## Adaptive Training"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eaac2ddc-ad53-40db-804b-7f54f3000476",
   "metadata": {},
   "source": [
    "Now all we need to do is simply define the PDE loss for this problem."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "f18ab849-3c05-418a-a30b-3928f77c332d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# PDE Loss\n",
    "def pde_loss(model, collocs):\n",
    "    # Eq. parameter\n",
    "    D = jnp.array(0.001, dtype=float)\n",
    "    c = jnp.array(5.0, dtype=float)\n",
    "\n",
    "    def u(x):\n",
    "        y = model(x)\n",
    "        return y\n",
    "        \n",
    "    # Physics Loss Terms\n",
    "    u_t = gradf(u, 0, 1)\n",
    "    u_xx = gradf(u, 1, 2)\n",
    "    \n",
    "    # Residual\n",
    "    pde_res = u_t(collocs) - D*u_xx(collocs) - c*(u(collocs)-(u(collocs)**3))\n",
    "    \n",
    "    return pde_res"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5b1e7cdc-12ae-40fc-aa3d-7bc8f0ef6596",
   "metadata": {},
   "source": [
    "The selected model instance will be trained for a total of $5\\cdot 10^4$ epochs, using a series of different adaptive techniques. First of all, the learning rate will be modified throughout training."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "3fed68c5-7d06-4c67-ab4b-426bf0160672",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Training epochs\n",
    "num_epochs = 50000\n",
    "\n",
    "# Define scheduler learning rates\n",
    "lr_vals = dict()\n",
    "lr_vals['init_lr'] = 0.001\n",
    "lr_vals['scales'] = {0 : 1.0, 15_000 : 0.6, 25_000 : 0.8}\n",
    "\n",
    "# Setup scheduler for optimizer\n",
    "scheduler = optax.piecewise_constant_schedule(\n",
    "    init_value=lr_vals['init_lr'],\n",
    "    boundaries_and_scales=lr_vals['scales']\n",
    ")\n",
    "\n",
    "# We will also use the Nesterov version of Adam\n",
    "opt_type = optax.adam(learning_rate=scheduler, nesterov=True)\n",
    "\n",
    "# Define the optimizer\n",
    "optimizer = nnx.Optimizer(model, opt_type)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "38aebe64-a3a4-48c4-b675-dda2c22d93ae",
   "metadata": {},
   "source": [
    "Throughout training, apart from grid updates, i.e. a combination of extending the grid and subsequently adapting it on the data, we may perform grid adaptations alone."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "20413b5e-4f43-4503-96a3-8e232280075b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define epochs for grid extension, along with grid sizes\n",
    "grid_extend = {0 : 3, 5000 : 8, 20_000 : 12}\n",
    "\n",
    "# Define epochs for grid adaptation - in this case we opt not to\n",
    "grid_adapt = []"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8d4e6678-8a02-4321-a8c5-5d12d5356c0c",
   "metadata": {},
   "source": [
    "In cases where domain expertise is available, one may choose to scale each term of the total loss function in a way that justifies prioritizing a certain boundary condition, or the PDE loss, etc. For this purpose, one may define global weights, although in this example they are all set equal to one. Additionally, one may also define local weights, for the purposes of the RBA technique (more information can be found in the paper mentioned at the start of the tutorial)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "e9de3376-c916-4440-8520-53c6ce57e29a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define global loss weights\n",
    "glob_w = [jnp.array(1.0, dtype=float), jnp.array(1.0, dtype=float), jnp.array(1.0, dtype=float), jnp.array(1.0, dtype=float)]\n",
    "\n",
    "# Initialize RBA weights\n",
    "loc_w = [jnp.ones((collocs.shape[0],1)), jnp.ones((BC1_colloc.shape[0],1)),\n",
    "         jnp.ones((BC2_colloc.shape[0],1)), jnp.ones((BC3_colloc.shape[0],1))]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "97816338-1ff3-459c-b09f-0449f27acf07",
   "metadata": {},
   "source": [
    "Depending on if the user chooses to define local weights or not, they have to use either the `vanilla` or the `adaptive` version of the loss function, by calling the `get_vanilla_loss` or the `get_adaptive_loss` method, respectively. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "80fc8e95-0c10-4c6c-90f4-f1dd16e1a2ea",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define loss function, depending on if the user wants to use RBA weights or not\n",
    "if loc_w is None:\n",
    "    loss_fn = get_vanilla_loss(pde_loss, model)\n",
    "else:\n",
    "    loss_fn = get_adaptive_loss(pde_loss, model)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "200f6170-97b1-45b9-b5c5-b492a770ec75",
   "metadata": {},
   "source": [
    "Note that even if they do not use RBA weights and therefore choose the vanilla loss, they may still train a PIKAN adaptively by implementing other techniques. One such technique is the adaptive re-sampling of collocation points."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "28f31a16-942b-40bb-907d-9c35bd897fac",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Perform adaptive collocation point sampling\n",
    "colloc_adapt = {'lower_point' : np.array([0,-1]), 'upper_point' : np.array([1,1]),\n",
    "                'M' : 2**16, 'k' : jnp.array(1.0, dtype=float), 'c' : jnp.array(1.0, dtype=float),\n",
    "                'epochs' : [10_000, 20_000]}\n",
    "\n",
    "if colloc_adapt['epochs']:\n",
    "    # Define the function\n",
    "    def resample_collocs(model, collocs, sample, k=jnp.array(1.0), c=jnp.array(1.0)):\n",
    "        # Calculate residuals of PDE\n",
    "        resids = jnp.abs(pde_loss(model, sample))\n",
    "        # Raise to power k\n",
    "        ek = jnp.power(resids, k)\n",
    "        # Divide by mean and add c\n",
    "        px = (ek/jnp.mean(ek)) + c\n",
    "        # Normalize\n",
    "        px_norm = (px / jnp.sum(px))[:,0]\n",
    "        # Draw ids for the sampled points using px_norm\n",
    "        X_ids = jax.random.choice(key=jax.random.PRNGKey(0), a=sample.shape[0], shape=(collocs.shape[0],), replace=False, p=px_norm)\n",
    "        # Replace collocation points\n",
    "        new_collocs = sample[X_ids]\n",
    "    \n",
    "        return new_collocs\n",
    "\n",
    "    # Sample M points from Sobol\n",
    "    M = colloc_adapt['M']\n",
    "    lp = colloc_adapt['lower_point']\n",
    "    up = colloc_adapt['upper_point']\n",
    "    sample = jnp.array(sobol_sample(lp, up, M))\n",
    "    # Draw k, c hyperparameters\n",
    "    k, c = colloc_adapt['k'], colloc_adapt['c']"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d662fb12-9fcb-426d-827d-d3597e315152",
   "metadata": {},
   "source": [
    "Based on these, we may start training the adaptive PIKAN to solve the Allen-Cahn Equation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "7730f45c-73de-4a59-91bb-10f78a6b6a93",
   "metadata": {},
   "outputs": [],
   "source": [
    "@nnx.jit\n",
    "def train_step(model, optimizer, collocs, bc_collocs, bc_data, glob_w, loc_w):\n",
    "    \n",
    "    (loss, loc_w), grads = nnx.value_and_grad(loss_fn, has_aux=True)(model, collocs, bc_collocs, bc_data, glob_w, loc_w)\n",
    "    optimizer.update(grads)\n",
    "\n",
    "    return loss, loc_w"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "2d924c63-3713-41ff-b558-0e72d905d23d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 0: Performing grid update\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "E0407 11:43:53.140903  377909 hlo_lexer.cc:443] Failed to parse int literal: 71853406255713602929\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 5000: Performing grid update\n",
      "Epoch 20000: Performing grid update\n"
     ]
    }
   ],
   "source": [
    "train_losses = jnp.zeros((num_epochs,))\n",
    "adapt_state = True\n",
    "\n",
    "# Start training\n",
    "update_val = grid_extend[0]\n",
    "for epoch in range(num_epochs):\n",
    "    if epoch in colloc_adapt['epochs']:\n",
    "        # Get new colloc points\n",
    "        collocs = resample_collocs(model, collocs, sample, k, c)\n",
    "\n",
    "        # Restart training loc_w for the PDE if we're doing RBA\n",
    "        if loc_w is not None:\n",
    "            new_loc_w = jnp.full_like(loc_w[0], jnp.mean(loc_w[0]))\n",
    "            loc_w[0] = new_loc_w\n",
    "\n",
    "        # A grid adaptation is necessary for base/spline after resampling\n",
    "        if model.layer_type in ['base', 'spline']:\n",
    "            G = model.layers[0].grid.G\n",
    "            model.update_grids(collocs, G)\n",
    "\n",
    "    # Check if we're in an adapt epoch - this pertains only to base/spline layers\n",
    "    if (epoch in grid_adapt) and (model.layer_type in ['base', 'spline']):\n",
    "        model.update_grids(collocs, update_val)\n",
    "\n",
    "    # Check if we're in an extension epoch\n",
    "    if epoch in grid_extend.keys():\n",
    "        # If the layer is not base/spline type, then there should be no update on epoch 0\n",
    "        if (model.layer_type not in ['base', 'spline']) and (epoch == 0):\n",
    "            pass\n",
    "        else:\n",
    "            print(f\"Epoch {epoch}: Performing grid update\")\n",
    "            # Get grid size\n",
    "            update_val = grid_extend[epoch]\n",
    "            # Perform the update\n",
    "            model.update_grids(collocs, update_val)\n",
    "    \n",
    "            # Optimizer Transition - necessary only for epochs =/= 0, where there is actual extension\n",
    "            if adapt_state and (epoch != 0):\n",
    "                _, model_state = nnx.split(model)\n",
    "                old_state = optimizer.opt_state\n",
    "                adam_transition(old_state, model_state)\n",
    "            else:\n",
    "                optimizer = nnx.Optimizer(model, opt_type)\n",
    "        \n",
    "\n",
    "    loss, loc_w = train_step(model, optimizer, collocs, bc_collocs, bc_data, glob_w, loc_w)\n",
    "    # Append the loss\n",
    "    train_losses = train_losses.at[epoch].set(loss)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "28afaae8-61a1-46a9-85e5-f5521addb95c",
   "metadata": {},
   "source": [
    "All of the above have been neatly incorporated into the `train_PIKAN` method of `jaxkan.utils.PIKAN` module, so adaptively training a PIKAN is as simple as calling the function with the proper arguments, as follows:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9082d942-eb9a-44b9-824c-2f8ed4eb94c0",
   "metadata": {},
   "source": [
    "```python\n",
    "from jaxkan.utils.PIKAN import train_PIKAN\n",
    "\n",
    "num_epochs = 50000\n",
    "\n",
    "lr_vals = dict()\n",
    "lr_vals['init_lr'] = 0.001\n",
    "lr_vals['scales'] = {0 : 1.0, 15_000 : 0.6, 25_000 : 0.8}\n",
    "\n",
    "# Define epochs for grid extension, along with grid sizes\n",
    "grid_extend = {0 : 3, 5000 : 8, 20_000 : 12}\n",
    "\n",
    "# Define epochs for grid adaptation - in this case we opt not to\n",
    "grid_adapt = []\n",
    "\n",
    "# Define global loss weights\n",
    "glob_w = [jnp.array(1.0, dtype=float), jnp.array(1.0, dtype=float), jnp.array(1.0, dtype=float), jnp.array(1.0, dtype=float)]\n",
    "\n",
    "# Initialize RBA weights\n",
    "loc_w = [jnp.ones((collocs.shape[0],1)), jnp.ones((BC1_colloc.shape[0],1)),\n",
    "         jnp.ones((BC2_colloc.shape[0],1)), jnp.ones((BC3_colloc.shape[0],1))]\n",
    "\n",
    "# Perform adaptive collocation point sampling\n",
    "colloc_adapt = {'lower_point' : np.array([0,-1]), 'upper_point' : np.array([1,1]),\n",
    "                'M' : 2**16, 'k' : jnp.array(1.0, dtype=float), 'c' : jnp.array(1.0, dtype=float),\n",
    "                'epochs' : [10_000, 20_000]}\n",
    "\n",
    "model, train_losses = train_PIKAN(model, pde_loss, collocs, bc_collocs, bc_data, glob_w=glob_w, \n",
    "                                  lr_vals=lr_vals, collect_loss=True, adapt_state=True, loc_w=loc_w,\n",
    "                                  nesterov=True, num_epochs=num_epochs, grid_extend=grid_extend,\n",
    "                                  grid_adapt=grid_adapt, colloc_adapt=colloc_adapt)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "faab949e-dadb-4cec-bc13-63b10cb609c5",
   "metadata": {},
   "source": [
    "## Evaluation"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0b482774-013c-4f1a-98dc-6e3a44171783",
   "metadata": {},
   "source": [
    "By visualizing the train loss curve, we indeed see how the adaptive training techniques implemented lead to a significantly small training error by the end of training."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "8e82910c-d539-4ae1-adb4-c8d3caf597ce",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 700x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(7, 4))\n",
    "\n",
    "plt.plot(np.array(train_losses), label='Train Loss', marker='o', color='#25599c', markersize=1)\n",
    "\n",
    "plt.xlabel('Epochs')\n",
    "plt.ylabel('Loss')\n",
    "plt.title('Training Loss Over Epochs')\n",
    "plt.yscale('log')\n",
    "\n",
    "plt.legend()\n",
    "plt.grid(True, which='both', linestyle='--', linewidth=0.5) \n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4860724c-a72f-41cf-8882-902e5c05f601",
   "metadata": {},
   "source": [
    "Additionally, we observe a good approximation to the actual solution to the Allen-Cahn equation, which cannot be obtained without utilizing any adaptive technique."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "7798eb68-d6b5-47ec-b845-cf3d60dccf23",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 700x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "N_t, N_x = 100, 256\n",
    "\n",
    "t = np.linspace(0.0, 1.0, N_t)\n",
    "x = np.linspace(-1.0, 1.0, N_x)\n",
    "T, X = np.meshgrid(t, x, indexing='ij')\n",
    "coords = np.stack([T.flatten(), X.flatten()], axis=1)\n",
    "\n",
    "output = model(jnp.array(coords))\n",
    "resplot = np.array(output).reshape(N_t, N_x)\n",
    "\n",
    "plt.figure(figsize=(7, 4))\n",
    "plt.pcolormesh(T, X, resplot, shading='auto', cmap='Spectral_r')\n",
    "plt.colorbar()\n",
    "\n",
    "plt.title('Solution of Allen-Cahn Equation')\n",
    "plt.xlabel('t')\n",
    "\n",
    "plt.ylabel('x')\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "88cc341a-8869-4dd9-be77-ef9bf2d8b5c1",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
